/*
** Lua binding: MyGame
** Generated automatically by tolua++-1.0.92 on 07/14/13 23:54:18.
*/

/****************************************************************************
 Copyright (c) 2011 cocos2d-x.org

 http://www.cocos2d-x.org

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ****************************************************************************/



#include "LuaCocos2d.h"
#include "tolua_fix.h"
#include "CC2DFileCache.h"
#include "CC2DNodeFile.h"
#include "CCATFileCache.h"
#include "XmlParser.h"
#include "ActionExt.h"
#include "SpriteExt.h"
#include "cocos2d.h"
#include "Misc.h"
#include <string>
#include "UIWidget.h"
#include "UIButton.h"

/* function to release collected object via destructor */
#ifdef __cplusplus

static int tolua_collect_VDeleteNode (lua_State* tolua_S)
{
 VDeleteNode* self = (VDeleteNode*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_std__vector_int_ (lua_State* tolua_S)
{
 std::vector<int>* self = (std::vector<int>*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_cocos2d__ccColor4B (lua_State* tolua_S)
{
 cocos2d::ccColor4B* self = (cocos2d::ccColor4B*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_SpriteExt (lua_State* tolua_S)
{
 SpriteExt* self = (SpriteExt*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CC2DParticleSystem (lua_State* tolua_S)
{
 CC2DParticleSystem* self = (CC2DParticleSystem*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_VSetGridNull (lua_State* tolua_S)
{
 VSetGridNull* self = (VSetGridNull*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CC2DLayer (lua_State* tolua_S)
{
 CC2DLayer* self = (CC2DLayer*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CC2DSpriteExt (lua_State* tolua_S)
{
 CC2DSpriteExt* self = (CC2DSpriteExt*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CC2DFileCache (lua_State* tolua_S)
{
 CC2DFileCache* self = (CC2DFileCache*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_cocos2d__CCSize (lua_State* tolua_S)
{
 cocos2d::CCSize* self = (cocos2d::CCSize*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_std__vector_std__string_ (lua_State* tolua_S)
{
 std::vector<std::string>* self = (std::vector<std::string>*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_UIButton (lua_State* tolua_S)
{
 UIButton* self = (UIButton*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_cocos2d__CCPoint (lua_State* tolua_S)
{
 cocos2d::CCPoint* self = (cocos2d::CCPoint*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CC2DProgressTimer (lua_State* tolua_S)
{
 CC2DProgressTimer* self = (CC2DProgressTimer*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CC2DNode (lua_State* tolua_S)
{
 CC2DNode* self = (CC2DNode*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_XmlParser (lua_State* tolua_S)
{
 XmlParser* self = (XmlParser*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CC2DCircle (lua_State* tolua_S)
{
 CC2DCircle* self = (CC2DCircle*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CC2DPolygon (lua_State* tolua_S)
{
 CC2DPolygon* self = (CC2DPolygon*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CCATFileCache (lua_State* tolua_S)
{
 CCATFileCache* self = (CCATFileCache*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CC2DMenuItemImage (lua_State* tolua_S)
{
 CC2DMenuItemImage* self = (CC2DMenuItemImage*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_std__vector_float_ (lua_State* tolua_S)
{
 std::vector<float>* self = (std::vector<float>*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_VCC2DLoad (lua_State* tolua_S)
{
 VCC2DLoad* self = (VCC2DLoad*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_UIWidget (lua_State* tolua_S)
{
 UIWidget* self = (UIWidget*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CC2DScene (lua_State* tolua_S)
{
 CC2DScene* self = (CC2DScene*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_xmlNodePtr (lua_State* tolua_S)
{
 xmlNodePtr* self = (xmlNodePtr*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CC2DBody (lua_State* tolua_S)
{
 CC2DBody* self = (CC2DBody*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_VNodeRunAction (lua_State* tolua_S)
{
 VNodeRunAction* self = (VNodeRunAction*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CC2DParallaxNode (lua_State* tolua_S)
{
 CC2DParallaxNode* self = (CC2DParallaxNode*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_VSoundPlay (lua_State* tolua_S)
{
 VSoundPlay* self = (VSoundPlay*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CC2DMenu (lua_State* tolua_S)
{
 CC2DMenu* self = (CC2DMenu*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CC2DRectangle (lua_State* tolua_S)
{
 CC2DRectangle* self = (CC2DRectangle*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CC2DWorld (lua_State* tolua_S)
{
 CC2DWorld* self = (CC2DWorld*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_cocos2d__CCRect (lua_State* tolua_S)
{
 cocos2d::CCRect* self = (cocos2d::CCRect*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CC2DSprite (lua_State* tolua_S)
{
 CC2DSprite* self = (CC2DSprite*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"VDeleteNode");
 tolua_usertype(tolua_S,"std::vector<int>");
 tolua_usertype(tolua_S,"cocos2d::ccColor4B");
 tolua_usertype(tolua_S,"SpriteExt");
 tolua_usertype(tolua_S,"CC2DParticleSystem");
 tolua_usertype(tolua_S,"CCFiniteTimeAction");
 tolua_usertype(tolua_S,"CCNode");
 tolua_usertype(tolua_S,"VSetGridNull");
 tolua_usertype(tolua_S,"CC2DLayer");
 tolua_usertype(tolua_S,"CC2DSpriteExt");
 tolua_usertype(tolua_S,"CC2DFileCache");
 tolua_usertype(tolua_S,"cocos2d::CCSize");
 tolua_usertype(tolua_S,"CCScene");
 tolua_usertype(tolua_S,"UIButton");
 tolua_usertype(tolua_S,"int");
 tolua_usertype(tolua_S,"CCObject");
 tolua_usertype(tolua_S,"CCActionInstant");
 tolua_usertype(tolua_S,"CC2DProgressTimer");
 tolua_usertype(tolua_S,"CC2DNode");
 tolua_usertype(tolua_S,"CCLayer");
 tolua_usertype(tolua_S,"UIWidget");
 tolua_usertype(tolua_S,"XmlParser");
 tolua_usertype(tolua_S,"CC2DCircle");
 tolua_usertype(tolua_S,"Misc");
 tolua_usertype(tolua_S,"CCRect");
 tolua_usertype(tolua_S,"CC2DPolygon");
 tolua_usertype(tolua_S,"std::vector<float>");
 tolua_usertype(tolua_S,"CCATFileCache");
 tolua_usertype(tolua_S,"CC2DFixture");
 tolua_usertype(tolua_S,"CC2DBody");
 tolua_usertype(tolua_S,"VNodeRunAction");
 tolua_usertype(tolua_S,"CCAction");
 tolua_usertype(tolua_S,"b2World");
 tolua_usertype(tolua_S,"CC2DMenu");
 tolua_usertype(tolua_S,"CC2DMenuItemImage");
 tolua_usertype(tolua_S,"VSoundPlay");
 tolua_usertype(tolua_S,"VCC2DLoad");
 tolua_usertype(tolua_S,"std::vector<std::string>");
 tolua_usertype(tolua_S,"CC2DScene");
 tolua_usertype(tolua_S,"xmlNodePtr");
 tolua_usertype(tolua_S,"cocos2d::CCPoint");
 tolua_usertype(tolua_S,"cocos2d::CCRect");
 tolua_usertype(tolua_S,"CC2DSprite");
 tolua_usertype(tolua_S,"CCZone");
 tolua_usertype(tolua_S,"CCSprite");
 tolua_usertype(tolua_S,"CC2DRectangle");
 tolua_usertype(tolua_S,"b2Body");
 tolua_usertype(tolua_S,"CC2DParallaxNode");
 tolua_usertype(tolua_S,"CC2DWorld");
}

/* method: new of class  CC2DFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DFileCache_new00
static int tolua_MyGame_CC2DFileCache_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DFileCache",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DFileCache* tolua_ret = (CC2DFileCache*)  Mtolua_new((CC2DFileCache)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DFileCache");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DFileCache_new00_local
static int tolua_MyGame_CC2DFileCache_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DFileCache",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DFileCache* tolua_ret = (CC2DFileCache*)  Mtolua_new((CC2DFileCache)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DFileCache");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DFileCache_delete00
static int tolua_MyGame_CC2DFileCache_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DFileCache",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DFileCache* self = (CC2DFileCache*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: sharedCC2DFileCache of class  CC2DFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DFileCache_sharedCC2DFileCache00
static int tolua_MyGame_CC2DFileCache_sharedCC2DFileCache00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DFileCache",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DFileCache* tolua_ret = (CC2DFileCache*)  CC2DFileCache::sharedCC2DFileCache();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DFileCache");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'sharedCC2DFileCache'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addCC2DNode of class  CC2DFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DFileCache_addCC2DNode00
static int tolua_MyGame_CC2DFileCache_addCC2DNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DFileCache",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DFileCache* self = (CC2DFileCache*)  tolua_tousertype(tolua_S,1,0);
  const char* fileimage = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addCC2DNode'", NULL);
#endif
  {
   CC2DNode* tolua_ret = (CC2DNode*)  self->addCC2DNode(fileimage);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CC2DNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addCC2DNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DNode_new00
static int tolua_MyGame_CC2DNode_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DNode* tolua_ret = (CC2DNode*)  Mtolua_new((CC2DNode)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CC2DNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DNode_new00_local
static int tolua_MyGame_CC2DNode_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DNode* tolua_ret = (CC2DNode*)  Mtolua_new((CC2DNode)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CC2DNode");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DNode_delete00
static int tolua_MyGame_CC2DNode_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DNode* self = (CC2DNode*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DNode_createCCNode00
static int tolua_MyGame_CC2DNode_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DNode",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DNode* self = (CC2DNode*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initProperties of class  CC2DNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DNode_initProperties00
static int tolua_MyGame_CC2DNode_initProperties00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DNode",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DNode* self = (CC2DNode*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initProperties'", NULL);
#endif
  {
   self->initProperties(pNode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initProperties'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DNode_load00
static int tolua_MyGame_CC2DNode_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DNode",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DNode* self = (CC2DNode*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DSprite */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSprite_new00
static int tolua_MyGame_CC2DSprite_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DSprite",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DSprite* tolua_ret = (CC2DSprite*)  Mtolua_new((CC2DSprite)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CC2DSprite");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DSprite */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSprite_new00_local
static int tolua_MyGame_CC2DSprite_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DSprite",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DSprite* tolua_ret = (CC2DSprite*)  Mtolua_new((CC2DSprite)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CC2DSprite");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DSprite */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSprite_delete00
static int tolua_MyGame_CC2DSprite_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DSprite",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DSprite* self = (CC2DSprite*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DSprite */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSprite_createCCNode00
static int tolua_MyGame_CC2DSprite_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DSprite",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DSprite* self = (CC2DSprite*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initProperties of class  CC2DSprite */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSprite_initProperties00
static int tolua_MyGame_CC2DSprite_initProperties00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DSprite",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DSprite* self = (CC2DSprite*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initProperties'", NULL);
#endif
  {
   self->initProperties(pNode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initProperties'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DSprite */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSprite_load00
static int tolua_MyGame_CC2DSprite_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DSprite",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DSprite* self = (CC2DSprite*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DParticleSystem */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParticleSystem_new00
static int tolua_MyGame_CC2DParticleSystem_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DParticleSystem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DParticleSystem* tolua_ret = (CC2DParticleSystem*)  Mtolua_new((CC2DParticleSystem)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CC2DParticleSystem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DParticleSystem */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParticleSystem_new00_local
static int tolua_MyGame_CC2DParticleSystem_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DParticleSystem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DParticleSystem* tolua_ret = (CC2DParticleSystem*)  Mtolua_new((CC2DParticleSystem)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CC2DParticleSystem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DParticleSystem */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParticleSystem_delete00
static int tolua_MyGame_CC2DParticleSystem_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DParticleSystem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DParticleSystem* self = (CC2DParticleSystem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DParticleSystem */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParticleSystem_createCCNode00
static int tolua_MyGame_CC2DParticleSystem_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DParticleSystem",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DParticleSystem* self = (CC2DParticleSystem*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initProperties of class  CC2DParticleSystem */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParticleSystem_initProperties00
static int tolua_MyGame_CC2DParticleSystem_initProperties00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DParticleSystem",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DParticleSystem* self = (CC2DParticleSystem*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initProperties'", NULL);
#endif
  {
   self->initProperties(pNode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initProperties'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DParticleSystem */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParticleSystem_load00
static int tolua_MyGame_CC2DParticleSystem_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DParticleSystem",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DParticleSystem* self = (CC2DParticleSystem*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DLayer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DLayer_new00
static int tolua_MyGame_CC2DLayer_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DLayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DLayer* tolua_ret = (CC2DLayer*)  Mtolua_new((CC2DLayer)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CC2DLayer");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DLayer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DLayer_new00_local
static int tolua_MyGame_CC2DLayer_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DLayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DLayer* tolua_ret = (CC2DLayer*)  Mtolua_new((CC2DLayer)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CC2DLayer");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DLayer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DLayer_delete00
static int tolua_MyGame_CC2DLayer_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DLayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DLayer* self = (CC2DLayer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DLayer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DLayer_createCCNode00
static int tolua_MyGame_CC2DLayer_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DLayer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DLayer* self = (CC2DLayer*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initProperties of class  CC2DLayer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DLayer_initProperties00
static int tolua_MyGame_CC2DLayer_initProperties00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DLayer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DLayer* self = (CC2DLayer*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initProperties'", NULL);
#endif
  {
   self->initProperties(pNode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initProperties'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DLayer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DLayer_load00
static int tolua_MyGame_CC2DLayer_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DLayer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DLayer* self = (CC2DLayer*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DProgressTimer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DProgressTimer_new00
static int tolua_MyGame_CC2DProgressTimer_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DProgressTimer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DProgressTimer* tolua_ret = (CC2DProgressTimer*)  Mtolua_new((CC2DProgressTimer)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CC2DProgressTimer");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DProgressTimer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DProgressTimer_new00_local
static int tolua_MyGame_CC2DProgressTimer_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DProgressTimer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DProgressTimer* tolua_ret = (CC2DProgressTimer*)  Mtolua_new((CC2DProgressTimer)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CC2DProgressTimer");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DProgressTimer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DProgressTimer_delete00
static int tolua_MyGame_CC2DProgressTimer_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DProgressTimer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DProgressTimer* self = (CC2DProgressTimer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DProgressTimer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DProgressTimer_createCCNode00
static int tolua_MyGame_CC2DProgressTimer_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DProgressTimer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DProgressTimer* self = (CC2DProgressTimer*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initProperties of class  CC2DProgressTimer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DProgressTimer_initProperties00
static int tolua_MyGame_CC2DProgressTimer_initProperties00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DProgressTimer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DProgressTimer* self = (CC2DProgressTimer*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initProperties'", NULL);
#endif
  {
   self->initProperties(pNode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initProperties'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DProgressTimer */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DProgressTimer_load00
static int tolua_MyGame_CC2DProgressTimer_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DProgressTimer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DProgressTimer* self = (CC2DProgressTimer*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DParallaxNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParallaxNode_new00
static int tolua_MyGame_CC2DParallaxNode_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DParallaxNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DParallaxNode* tolua_ret = (CC2DParallaxNode*)  Mtolua_new((CC2DParallaxNode)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DParallaxNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DParallaxNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParallaxNode_new00_local
static int tolua_MyGame_CC2DParallaxNode_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DParallaxNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DParallaxNode* tolua_ret = (CC2DParallaxNode*)  Mtolua_new((CC2DParallaxNode)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DParallaxNode");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DParallaxNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParallaxNode_delete00
static int tolua_MyGame_CC2DParallaxNode_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DParallaxNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DParallaxNode* self = (CC2DParallaxNode*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DParallaxNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DParallaxNode_createCCNode00
static int tolua_MyGame_CC2DParallaxNode_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DParallaxNode",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DParallaxNode* self = (CC2DParallaxNode*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DScene */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DScene_new00
static int tolua_MyGame_CC2DScene_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DScene",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DScene* tolua_ret = (CC2DScene*)  Mtolua_new((CC2DScene)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DScene");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DScene */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DScene_new00_local
static int tolua_MyGame_CC2DScene_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DScene",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DScene* tolua_ret = (CC2DScene*)  Mtolua_new((CC2DScene)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DScene");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DScene */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DScene_delete00
static int tolua_MyGame_CC2DScene_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DScene",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DScene* self = (CC2DScene*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DScene */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DScene_createCCNode00
static int tolua_MyGame_CC2DScene_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DScene",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DScene* self = (CC2DScene*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCScene* tolua_ret = (CCScene*)  self->createCCNode(parent);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCScene");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DMenu */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenu_new00
static int tolua_MyGame_CC2DMenu_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DMenu",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DMenu* tolua_ret = (CC2DMenu*)  Mtolua_new((CC2DMenu)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DMenu");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DMenu */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenu_new00_local
static int tolua_MyGame_CC2DMenu_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DMenu",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DMenu* tolua_ret = (CC2DMenu*)  Mtolua_new((CC2DMenu)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DMenu");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DMenu */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenu_delete00
static int tolua_MyGame_CC2DMenu_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DMenu",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DMenu* self = (CC2DMenu*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DMenu */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenu_createCCNode00
static int tolua_MyGame_CC2DMenu_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DMenu",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DMenu* self = (CC2DMenu*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DMenuItemImage */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenuItemImage_new00
static int tolua_MyGame_CC2DMenuItemImage_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DMenuItemImage",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DMenuItemImage* tolua_ret = (CC2DMenuItemImage*)  Mtolua_new((CC2DMenuItemImage)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DMenuItemImage");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DMenuItemImage */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenuItemImage_new00_local
static int tolua_MyGame_CC2DMenuItemImage_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DMenuItemImage",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DMenuItemImage* tolua_ret = (CC2DMenuItemImage*)  Mtolua_new((CC2DMenuItemImage)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DMenuItemImage");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DMenuItemImage */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenuItemImage_delete00
static int tolua_MyGame_CC2DMenuItemImage_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DMenuItemImage",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DMenuItemImage* self = (CC2DMenuItemImage*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DMenuItemImage */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenuItemImage_createCCNode00
static int tolua_MyGame_CC2DMenuItemImage_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DMenuItemImage",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DMenuItemImage* self = (CC2DMenuItemImage*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initProperties of class  CC2DMenuItemImage */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenuItemImage_initProperties00
static int tolua_MyGame_CC2DMenuItemImage_initProperties00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DMenuItemImage",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DMenuItemImage* self = (CC2DMenuItemImage*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initProperties'", NULL);
#endif
  {
   self->initProperties(pNode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initProperties'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DMenuItemImage */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DMenuItemImage_load00
static int tolua_MyGame_CC2DMenuItemImage_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DMenuItemImage",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DMenuItemImage* self = (CC2DMenuItemImage*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DSpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSpriteExt_new00
static int tolua_MyGame_CC2DSpriteExt_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DSpriteExt",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DSpriteExt* tolua_ret = (CC2DSpriteExt*)  Mtolua_new((CC2DSpriteExt)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DSpriteExt");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DSpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSpriteExt_new00_local
static int tolua_MyGame_CC2DSpriteExt_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DSpriteExt",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DSpriteExt* tolua_ret = (CC2DSpriteExt*)  Mtolua_new((CC2DSpriteExt)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DSpriteExt");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DSpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSpriteExt_delete00
static int tolua_MyGame_CC2DSpriteExt_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DSpriteExt",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DSpriteExt* self = (CC2DSpriteExt*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCCNode of class  CC2DSpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSpriteExt_createCCNode00
static int tolua_MyGame_CC2DSpriteExt_createCCNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DSpriteExt",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DSpriteExt* self = (CC2DSpriteExt*)  tolua_tousertype(tolua_S,1,0);
  CCNode* parent = ((CCNode*)  tolua_tousertype(tolua_S,2,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCCNode'", NULL);
#endif
  {
   CCNode* tolua_ret = (CCNode*)  self->createCCNode(parent);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCCNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initProperties of class  CC2DSpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSpriteExt_initProperties00
static int tolua_MyGame_CC2DSpriteExt_initProperties00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DSpriteExt",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DSpriteExt* self = (CC2DSpriteExt*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initProperties'", NULL);
#endif
  {
   self->initProperties(pNode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initProperties'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DSpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DSpriteExt_load00
static int tolua_MyGame_CC2DSpriteExt_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DSpriteExt",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DSpriteExt* self = (CC2DSpriteExt*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DWorld */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DWorld_new00
static int tolua_MyGame_CC2DWorld_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DWorld* tolua_ret = (CC2DWorld*)  Mtolua_new((CC2DWorld)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DWorld");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DWorld */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DWorld_new00_local
static int tolua_MyGame_CC2DWorld_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DWorld* tolua_ret = (CC2DWorld*)  Mtolua_new((CC2DWorld)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DWorld");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DWorld */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DWorld_delete00
static int tolua_MyGame_CC2DWorld_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DWorld* self = (CC2DWorld*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createWorld of class  CC2DWorld */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DWorld_createWorld00
static int tolua_MyGame_CC2DWorld_createWorld00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DWorld* self = (CC2DWorld*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createWorld'", NULL);
#endif
  {
   b2World* tolua_ret = (b2World*)  self->createWorld();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"b2World");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createWorld'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DWorld */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DWorld_load00
static int tolua_MyGame_CC2DWorld_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DWorld* self = (CC2DWorld*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DBody */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DBody_new00
static int tolua_MyGame_CC2DBody_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DBody",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DBody* tolua_ret = (CC2DBody*)  Mtolua_new((CC2DBody)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DBody");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DBody */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DBody_new00_local
static int tolua_MyGame_CC2DBody_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DBody",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DBody* tolua_ret = (CC2DBody*)  Mtolua_new((CC2DBody)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DBody");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DBody */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DBody_delete00
static int tolua_MyGame_CC2DBody_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DBody",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DBody* self = (CC2DBody*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createBody of class  CC2DBody */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DBody_createBody00
static int tolua_MyGame_CC2DBody_createBody00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DBody",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"b2World",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DBody* self = (CC2DBody*)  tolua_tousertype(tolua_S,1,0);
  b2World* world = ((b2World*)  tolua_tousertype(tolua_S,2,0));
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createBody'", NULL);
#endif
  {
   b2Body* tolua_ret = (b2Body*)  self->createBody(world,pNode);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"b2Body");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createBody'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DBody */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DBody_load00
static int tolua_MyGame_CC2DBody_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DBody",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DBody* self = (CC2DBody*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DCircle */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DCircle_new00
static int tolua_MyGame_CC2DCircle_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DCircle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DCircle* tolua_ret = (CC2DCircle*)  Mtolua_new((CC2DCircle)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DCircle");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DCircle */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DCircle_new00_local
static int tolua_MyGame_CC2DCircle_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DCircle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DCircle* tolua_ret = (CC2DCircle*)  Mtolua_new((CC2DCircle)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DCircle");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DCircle */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DCircle_delete00
static int tolua_MyGame_CC2DCircle_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DCircle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DCircle* self = (CC2DCircle*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DCircle */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DCircle_load00
static int tolua_MyGame_CC2DCircle_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DCircle",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CC2DNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DCircle* self = (CC2DCircle*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
  CC2DNode* pNode = ((CC2DNode*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser,pNode);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DRectangle */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DRectangle_new00
static int tolua_MyGame_CC2DRectangle_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DRectangle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DRectangle* tolua_ret = (CC2DRectangle*)  Mtolua_new((CC2DRectangle)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DRectangle");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DRectangle */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DRectangle_new00_local
static int tolua_MyGame_CC2DRectangle_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DRectangle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DRectangle* tolua_ret = (CC2DRectangle*)  Mtolua_new((CC2DRectangle)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DRectangle");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DRectangle */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DRectangle_delete00
static int tolua_MyGame_CC2DRectangle_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DRectangle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DRectangle* self = (CC2DRectangle*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DRectangle */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DRectangle_load00
static int tolua_MyGame_CC2DRectangle_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DRectangle",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CC2DNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DRectangle* self = (CC2DRectangle*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
  CC2DNode* pNode = ((CC2DNode*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser,pNode);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CC2DPolygon */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DPolygon_new00
static int tolua_MyGame_CC2DPolygon_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DPolygon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DPolygon* tolua_ret = (CC2DPolygon*)  Mtolua_new((CC2DPolygon)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DPolygon");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CC2DPolygon */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DPolygon_new00_local
static int tolua_MyGame_CC2DPolygon_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CC2DPolygon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CC2DPolygon* tolua_ret = (CC2DPolygon*)  Mtolua_new((CC2DPolygon)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CC2DPolygon");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CC2DPolygon */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DPolygon_delete00
static int tolua_MyGame_CC2DPolygon_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DPolygon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DPolygon* self = (CC2DPolygon*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: load of class  CC2DPolygon */
#ifndef TOLUA_DISABLE_tolua_MyGame_CC2DPolygon_load00
static int tolua_MyGame_CC2DPolygon_load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CC2DPolygon",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"XmlParser",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CC2DNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CC2DPolygon* self = (CC2DPolygon*)  tolua_tousertype(tolua_S,1,0);
  XmlParser* xmlParser = ((XmlParser*)  tolua_tousertype(tolua_S,2,0));
  CC2DNode* pNode = ((CC2DNode*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'load'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->load(*xmlParser,pNode);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CCATFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CCATFileCache_new00
static int tolua_MyGame_CCATFileCache_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CCATFileCache",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CCATFileCache* tolua_ret = (CCATFileCache*)  Mtolua_new((CCATFileCache)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCATFileCache");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CCATFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CCATFileCache_new00_local
static int tolua_MyGame_CCATFileCache_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CCATFileCache",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CCATFileCache* tolua_ret = (CCATFileCache*)  Mtolua_new((CCATFileCache)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCATFileCache");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CCATFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CCATFileCache_delete00
static int tolua_MyGame_CCATFileCache_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CCATFileCache",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCATFileCache* self = (CCATFileCache*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: sharedCCATFileCache of class  CCATFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CCATFileCache_sharedCCATFileCache00
static int tolua_MyGame_CCATFileCache_sharedCCATFileCache00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CCATFileCache",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CCATFileCache* tolua_ret = (CCATFileCache*)  CCATFileCache::sharedCCATFileCache();
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCATFileCache");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'sharedCCATFileCache'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: findAction of class  CCATFileCache */
#ifndef TOLUA_DISABLE_tolua_MyGame_CCATFileCache_findAction00
static int tolua_MyGame_CCATFileCache_findAction00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CCATFileCache",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCATFileCache* self = (CCATFileCache*)  tolua_tousertype(tolua_S,1,0);
  const char* actName = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* actFile = ((const char*)  tolua_tostring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'findAction'", NULL);
#endif
  {
   CCAction* tolua_ret = (CCAction*)  self->findAction(actName,actFile);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCAction");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'findAction'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_new00
static int tolua_MyGame_XmlParser_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* filename = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   XmlParser* tolua_ret = (XmlParser*)  Mtolua_new((XmlParser)(filename));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"XmlParser");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_new00_local
static int tolua_MyGame_XmlParser_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* filename = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   XmlParser* tolua_ret = (XmlParser*)  Mtolua_new((XmlParser)(filename));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"XmlParser");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_delete00
static int tolua_MyGame_XmlParser_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getBoolForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getBoolForKey00
static int tolua_MyGame_XmlParser_getBoolForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
  bool defaultValue = ((bool)  tolua_toboolean(tolua_S,4,false));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBoolForKey'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->getBoolForKey(pKey,index,defaultValue);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getBoolForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIntegerForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getIntegerForKey00
static int tolua_MyGame_XmlParser_getIntegerForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
  int defautValue = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIntegerForKey'", NULL);
#endif
  {
   int tolua_ret = (int)  self->getIntegerForKey(pKey,index,defautValue);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIntegerForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIntArrayForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getIntArrayForKey00
static int tolua_MyGame_XmlParser_getIntArrayForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIntArrayForKey'", NULL);
#endif
  {
   std::vector<int> tolua_ret = (std::vector<int>)  self->getIntArrayForKey(pKey,index);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((std::vector<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::vector<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIntArrayForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFloatArrayForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getFloatArrayForKey00
static int tolua_MyGame_XmlParser_getFloatArrayForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFloatArrayForKey'", NULL);
#endif
  {
   std::vector<float> tolua_ret = (std::vector<float>)  self->getFloatArrayForKey(pKey,index);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((std::vector<float>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::vector<float>));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFloatArrayForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFloatForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getFloatForKey00
static int tolua_MyGame_XmlParser_getFloatForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
  float defautValue = ((float)  tolua_tonumber(tolua_S,4,0.0f));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFloatForKey'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getFloatForKey(pKey,index,defautValue);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFloatForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDoubleForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getDoubleForKey00
static int tolua_MyGame_XmlParser_getDoubleForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
  double defautValue = ((double)  tolua_tonumber(tolua_S,4,0.0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDoubleForKey'", NULL);
#endif
  {
   double tolua_ret = (double)  self->getDoubleForKey(pKey,index,defautValue);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDoubleForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRectForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getRectForKey00
static int tolua_MyGame_XmlParser_getRectForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRectForKey'", NULL);
#endif
  {
   cocos2d::CCRect tolua_ret = (cocos2d::CCRect)  self->getRectForKey(pKey,index);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCRect)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCRect");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCRect));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCRect");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRectForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRectForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getRectForKey01
static int tolua_MyGame_XmlParser_getRectForKey01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const cocos2d::CCRect",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
  const cocos2d::CCRect* defaultRect = ((const cocos2d::CCRect*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRectForKey'", NULL);
#endif
  {
   cocos2d::CCRect tolua_ret = (cocos2d::CCRect)  self->getRectForKey(pKey,index,*defaultRect);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCRect)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCRect");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCRect));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCRect");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_MyGame_XmlParser_getRectForKey00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPointForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getPointForKey00
static int tolua_MyGame_XmlParser_getPointForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPointForKey'", NULL);
#endif
  {
   cocos2d::CCPoint tolua_ret = (cocos2d::CCPoint)  self->getPointForKey(pKey,index);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCPoint)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCPoint));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPointForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPointForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getPointForKey01
static int tolua_MyGame_XmlParser_getPointForKey01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const cocos2d::CCPoint",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
  const cocos2d::CCPoint* defaultPoint = ((const cocos2d::CCPoint*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPointForKey'", NULL);
#endif
  {
   cocos2d::CCPoint tolua_ret = (cocos2d::CCPoint)  self->getPointForKey(pKey,index,*defaultPoint);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCPoint)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCPoint));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_MyGame_XmlParser_getPointForKey00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSizeForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getSizeForKey00
static int tolua_MyGame_XmlParser_getSizeForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSizeForKey'", NULL);
#endif
  {
   cocos2d::CCSize tolua_ret = (cocos2d::CCSize)  self->getSizeForKey(pKey,index);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCSize)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCSize");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCSize));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCSize");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSizeForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSizeForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getSizeForKey01
static int tolua_MyGame_XmlParser_getSizeForKey01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const cocos2d::CCSize",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
  const cocos2d::CCSize* defaultSize = ((const cocos2d::CCSize*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSizeForKey'", NULL);
#endif
  {
   cocos2d::CCSize tolua_ret = (cocos2d::CCSize)  self->getSizeForKey(pKey,index,*defaultSize);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCSize)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCSize");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCSize));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCSize");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_MyGame_XmlParser_getSizeForKey00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getStringForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getStringForKey00
static int tolua_MyGame_XmlParser_getStringForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isstring(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
  const char* defaultValue = ((const char*)  tolua_tostring(tolua_S,4,""));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getStringForKey'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->getStringForKey(pKey,index,defaultValue);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getStringForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: gotoNextGroup of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_gotoNextGroup00
static int tolua_MyGame_XmlParser_gotoNextGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'gotoNextGroup'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->gotoNextGroup();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'gotoNextGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: gotoChildGroup of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_gotoChildGroup00
static int tolua_MyGame_XmlParser_gotoChildGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'gotoChildGroup'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->gotoChildGroup();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'gotoChildGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: curNodeName of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_curNodeName00
static int tolua_MyGame_XmlParser_curNodeName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'curNodeName'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->curNodeName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'curNodeName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: allPropertyNames of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_allPropertyNames00
static int tolua_MyGame_XmlParser_allPropertyNames00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'allPropertyNames'", NULL);
#endif
  {
   std::vector<std::string> tolua_ret = (std::vector<std::string>)  self->allPropertyNames();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((std::vector<std::string>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<std::string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::vector<std::string>));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<std::string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'allPropertyNames'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBoolForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_setBoolForKey00
static int tolua_MyGame_XmlParser_setBoolForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  bool value = ((bool)  tolua_toboolean(tolua_S,3,0));
  int index = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBoolForKey'", NULL);
#endif
  {
   self->setBoolForKey(pKey,value,index);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBoolForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setIntegerForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_setIntegerForKey00
static int tolua_MyGame_XmlParser_setIntegerForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int value = ((int)  tolua_tonumber(tolua_S,3,0));
  int index = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setIntegerForKey'", NULL);
#endif
  {
   self->setIntegerForKey(pKey,value,index);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setIntegerForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFloatForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_setFloatForKey00
static int tolua_MyGame_XmlParser_setFloatForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  float value = ((float)  tolua_tonumber(tolua_S,3,0));
  int index = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFloatForKey'", NULL);
#endif
  {
   self->setFloatForKey(pKey,value,index);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFloatForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDoubleForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_setDoubleForKey00
static int tolua_MyGame_XmlParser_setDoubleForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  double value = ((double)  tolua_tonumber(tolua_S,3,0));
  int index = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDoubleForKey'", NULL);
#endif
  {
   self->setDoubleForKey(pKey,value,index);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDoubleForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setStringForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_setStringForKey00
static int tolua_MyGame_XmlParser_setStringForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  std::string value = ((std::string)  tolua_tocppstring(tolua_S,3,0));
  int index = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setStringForKey'", NULL);
#endif
  {
   self->setStringForKey(pKey,value,index);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setStringForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAtrribute of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_setAtrribute00
static int tolua_MyGame_XmlParser_setAtrribute00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* value = ((const char*)  tolua_tostring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAtrribute'", NULL);
#endif
  {
   self->setAtrribute(pKey,value);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAtrribute'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAttribute of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getAttribute00
static int tolua_MyGame_XmlParser_getAttribute00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAttribute'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->getAttribute(pKey);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAttribute'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIntegerForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getIntegerForAttr00
static int tolua_MyGame_XmlParser_getIntegerForAttr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIntegerForAttr'", NULL);
#endif
  {
   int tolua_ret = (int)  self->getIntegerForAttr(pKey);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIntegerForAttr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPointForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getPointForAttr00
static int tolua_MyGame_XmlParser_getPointForAttr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPointForAttr'", NULL);
#endif
  {
   cocos2d::CCPoint tolua_ret = (cocos2d::CCPoint)  self->getPointForAttr(pKey);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCPoint)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCPoint));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPointForAttr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPointForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getPointForAttr01
static int tolua_MyGame_XmlParser_getPointForAttr01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cocos2d::CCPoint",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  const cocos2d::CCPoint* defaultPoint = ((const cocos2d::CCPoint*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPointForAttr'", NULL);
#endif
  {
   cocos2d::CCPoint tolua_ret = (cocos2d::CCPoint)  self->getPointForAttr(pKey,*defaultPoint);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCPoint)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCPoint));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_MyGame_XmlParser_getPointForAttr00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRectForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getRectForAttr00
static int tolua_MyGame_XmlParser_getRectForAttr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRectForAttr'", NULL);
#endif
  {
   cocos2d::CCRect tolua_ret = (cocos2d::CCRect)  self->getRectForAttr(pKey);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCRect)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCRect");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCRect));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCRect");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRectForAttr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRectForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getRectForAttr01
static int tolua_MyGame_XmlParser_getRectForAttr01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cocos2d::CCRect",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  const cocos2d::CCRect* defaultRect = ((const cocos2d::CCRect*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRectForAttr'", NULL);
#endif
  {
   cocos2d::CCRect tolua_ret = (cocos2d::CCRect)  self->getRectForAttr(pKey,*defaultRect);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCRect)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCRect");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCRect));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCRect");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_MyGame_XmlParser_getRectForAttr00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSizeForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getSizeForAttr00
static int tolua_MyGame_XmlParser_getSizeForAttr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSizeForAttr'", NULL);
#endif
  {
   cocos2d::CCSize tolua_ret = (cocos2d::CCSize)  self->getSizeForAttr(pKey);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCSize)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCSize");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCSize));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCSize");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSizeForAttr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSizeForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getSizeForAttr01
static int tolua_MyGame_XmlParser_getSizeForAttr01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cocos2d::CCSize",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  const cocos2d::CCSize* defaultSize = ((const cocos2d::CCSize*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSizeForAttr'", NULL);
#endif
  {
   cocos2d::CCSize tolua_ret = (cocos2d::CCSize)  self->getSizeForAttr(pKey,*defaultSize);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::CCSize)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCSize");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::CCSize));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::CCSize");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_MyGame_XmlParser_getSizeForAttr00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getColorForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getColorForAttr00
static int tolua_MyGame_XmlParser_getColorForAttr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getColorForAttr'", NULL);
#endif
  {
   cocos2d::ccColor4B tolua_ret = (cocos2d::ccColor4B)  self->getColorForAttr(pKey);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::ccColor4B)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::ccColor4B");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::ccColor4B));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::ccColor4B");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getColorForAttr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getColorForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getColorForAttr01
static int tolua_MyGame_XmlParser_getColorForAttr01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cocos2d::ccColor4B",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  const cocos2d::ccColor4B* defaultColor = ((const cocos2d::ccColor4B*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getColorForAttr'", NULL);
#endif
  {
   cocos2d::ccColor4B tolua_ret = (cocos2d::ccColor4B)  self->getColorForAttr(pKey,*defaultColor);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cocos2d::ccColor4B)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::ccColor4B");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cocos2d::ccColor4B));
     tolua_pushusertype(tolua_S,tolua_obj,"cocos2d::ccColor4B");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_MyGame_XmlParser_getColorForAttr00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDoubleForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getDoubleForAttr00
static int tolua_MyGame_XmlParser_getDoubleForAttr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  double defaultValue = ((double)  tolua_tonumber(tolua_S,3,0.0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDoubleForAttr'", NULL);
#endif
  {
   double tolua_ret = (double)  self->getDoubleForAttr(pKey,defaultValue);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDoubleForAttr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFloatForAttr of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getFloatForAttr00
static int tolua_MyGame_XmlParser_getFloatForAttr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  float defaultValue = ((float)  tolua_tonumber(tolua_S,3,0.0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFloatForAttr'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getFloatForAttr(pKey,defaultValue);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFloatForAttr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: beginGroup of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_beginGroup00
static int tolua_MyGame_XmlParser_beginGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* groupName = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'beginGroup'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->beginGroup(groupName,index);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'beginGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: endGroup of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_endGroup00
static int tolua_MyGame_XmlParser_endGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'endGroup'", NULL);
#endif
  {
   self->endGroup();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'endGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initXMLFile of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_initXMLFile00
static int tolua_MyGame_XmlParser_initXMLFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* filename = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initXMLFile'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->initXMLFile(filename);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initXMLFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: saveXMLFile of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_saveXMLFile00
static int tolua_MyGame_XmlParser_saveXMLFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'saveXMLFile'", NULL);
#endif
  {
   self->saveXMLFile();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'saveXMLFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reset of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_reset00
static int tolua_MyGame_XmlParser_reset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reset'", NULL);
#endif
  {
   self->reset();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isXMLFileExist of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_isXMLFileExist00
static int tolua_MyGame_XmlParser_isXMLFileExist00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* filename = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  XmlParser::isXMLFileExist(filename);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isXMLFileExist'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFileName of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getFileName00
static int tolua_MyGame_XmlParser_getFileName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFileName'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->getFileName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFileName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: newGroup of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_newGroup00
static int tolua_MyGame_XmlParser_newGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* groupName = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'newGroup'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->newGroup(groupName);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'newGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createXMLFile of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_createXMLFile00
static int tolua_MyGame_XmlParser_createXMLFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* newFileName = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  XmlParser::createXMLFile(newFileName);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createXMLFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getXMLNodeForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getXMLNodeForKey00
static int tolua_MyGame_XmlParser_getXMLNodeForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"xmlNodePtr",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  xmlNodePtr parentNode = *((xmlNodePtr*)  tolua_tousertype(tolua_S,3,0));
  int index = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getXMLNodeForKey'", NULL);
#endif
  {
   xmlNodePtr tolua_ret = (xmlNodePtr)  self->getXMLNodeForKey(pKey,parentNode,index);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((xmlNodePtr)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"xmlNodePtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(xmlNodePtr));
     tolua_pushusertype(tolua_S,tolua_obj,"xmlNodePtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getXMLNodeForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getValueForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_getValueForKey00
static int tolua_MyGame_XmlParser_getValueForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  int index = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getValueForKey'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->getValueForKey(pKey,index);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getValueForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setValueForKey of class  XmlParser */
#ifndef TOLUA_DISABLE_tolua_MyGame_XmlParser_setValueForKey00
static int tolua_MyGame_XmlParser_setValueForKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"XmlParser",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  XmlParser* self = (XmlParser*)  tolua_tousertype(tolua_S,1,0);
  const char* pKey = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* pValue = ((const char*)  tolua_tostring(tolua_S,3,0));
  int index = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setValueForKey'", NULL);
#endif
  {
   self->setValueForKey(pKey,pValue,index);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setValueForKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  VSoundPlay */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSoundPlay_new00
static int tolua_MyGame_VSoundPlay_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VSoundPlay",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VSoundPlay* tolua_ret = (VSoundPlay*)  Mtolua_new((VSoundPlay)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"VSoundPlay");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  VSoundPlay */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSoundPlay_new00_local
static int tolua_MyGame_VSoundPlay_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VSoundPlay",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VSoundPlay* tolua_ret = (VSoundPlay*)  Mtolua_new((VSoundPlay)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"VSoundPlay");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  VSoundPlay */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSoundPlay_delete00
static int tolua_MyGame_VSoundPlay_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSoundPlay",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSoundPlay* self = (VSoundPlay*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initWithFile of class  VSoundPlay */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSoundPlay_initWithFile00
static int tolua_MyGame_VSoundPlay_initWithFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSoundPlay",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSoundPlay* self = (VSoundPlay*)  tolua_tousertype(tolua_S,1,0);
  const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
  float volume = ((float)  tolua_tonumber(tolua_S,3,1.0f));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initWithFile'", NULL);
#endif
  {
   self->initWithFile(path,volume);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initWithFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: startWithTarget of class  VSoundPlay */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSoundPlay_startWithTarget00
static int tolua_MyGame_VSoundPlay_startWithTarget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSoundPlay",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSoundPlay* self = (VSoundPlay*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pTarget = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'startWithTarget'", NULL);
#endif
  {
   self->startWithTarget(pTarget);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'startWithTarget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reverse of class  VSoundPlay */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSoundPlay_reverse00
static int tolua_MyGame_VSoundPlay_reverse00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSoundPlay",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSoundPlay* self = (VSoundPlay*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reverse'", NULL);
#endif
  {
   CCFiniteTimeAction* tolua_ret = (CCFiniteTimeAction*)  self->reverse();
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCFiniteTimeAction");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reverse'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: copyWithZone of class  VSoundPlay */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSoundPlay_copyWithZone00
static int tolua_MyGame_VSoundPlay_copyWithZone00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSoundPlay",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCZone",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSoundPlay* self = (VSoundPlay*)  tolua_tousertype(tolua_S,1,0);
  CCZone* pZone = ((CCZone*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'copyWithZone'", NULL);
#endif
  {
   CCObject* tolua_ret = (CCObject*)  self->copyWithZone(pZone);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCObject");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'copyWithZone'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: action of class  VSoundPlay */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSoundPlay_action00
static int tolua_MyGame_VSoundPlay_action00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VSoundPlay",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
  float volume = ((float)  tolua_tonumber(tolua_S,3,1.0f));
  {
   VSoundPlay* tolua_ret = (VSoundPlay*)  VSoundPlay::action(path,volume);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"VSoundPlay");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'action'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  VDeleteNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_VDeleteNode_new00
static int tolua_MyGame_VDeleteNode_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VDeleteNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VDeleteNode* tolua_ret = (VDeleteNode*)  Mtolua_new((VDeleteNode)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"VDeleteNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  VDeleteNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_VDeleteNode_new00_local
static int tolua_MyGame_VDeleteNode_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VDeleteNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VDeleteNode* tolua_ret = (VDeleteNode*)  Mtolua_new((VDeleteNode)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"VDeleteNode");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  VDeleteNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_VDeleteNode_delete00
static int tolua_MyGame_VDeleteNode_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VDeleteNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VDeleteNode* self = (VDeleteNode*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: startWithTarget of class  VDeleteNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_VDeleteNode_startWithTarget00
static int tolua_MyGame_VDeleteNode_startWithTarget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VDeleteNode",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VDeleteNode* self = (VDeleteNode*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pTarget = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'startWithTarget'", NULL);
#endif
  {
   self->startWithTarget(pTarget);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'startWithTarget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reverse of class  VDeleteNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_VDeleteNode_reverse00
static int tolua_MyGame_VDeleteNode_reverse00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VDeleteNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VDeleteNode* self = (VDeleteNode*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reverse'", NULL);
#endif
  {
   CCFiniteTimeAction* tolua_ret = (CCFiniteTimeAction*)  self->reverse();
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCFiniteTimeAction");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reverse'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: copyWithZone of class  VDeleteNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_VDeleteNode_copyWithZone00
static int tolua_MyGame_VDeleteNode_copyWithZone00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VDeleteNode",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCZone",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VDeleteNode* self = (VDeleteNode*)  tolua_tousertype(tolua_S,1,0);
  CCZone* pZone = ((CCZone*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'copyWithZone'", NULL);
#endif
  {
   CCObject* tolua_ret = (CCObject*)  self->copyWithZone(pZone);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCObject");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'copyWithZone'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: action of class  VDeleteNode */
#ifndef TOLUA_DISABLE_tolua_MyGame_VDeleteNode_action00
static int tolua_MyGame_VDeleteNode_action00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VDeleteNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VDeleteNode* tolua_ret = (VDeleteNode*)  VDeleteNode::action();
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"VDeleteNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'action'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  VSetGridNull */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSetGridNull_new00
static int tolua_MyGame_VSetGridNull_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VSetGridNull",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VSetGridNull* tolua_ret = (VSetGridNull*)  Mtolua_new((VSetGridNull)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"VSetGridNull");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  VSetGridNull */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSetGridNull_new00_local
static int tolua_MyGame_VSetGridNull_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VSetGridNull",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VSetGridNull* tolua_ret = (VSetGridNull*)  Mtolua_new((VSetGridNull)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"VSetGridNull");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  VSetGridNull */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSetGridNull_delete00
static int tolua_MyGame_VSetGridNull_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSetGridNull",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSetGridNull* self = (VSetGridNull*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: startWithTarget of class  VSetGridNull */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSetGridNull_startWithTarget00
static int tolua_MyGame_VSetGridNull_startWithTarget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSetGridNull",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSetGridNull* self = (VSetGridNull*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pTarget = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'startWithTarget'", NULL);
#endif
  {
   self->startWithTarget(pTarget);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'startWithTarget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reverse of class  VSetGridNull */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSetGridNull_reverse00
static int tolua_MyGame_VSetGridNull_reverse00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSetGridNull",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSetGridNull* self = (VSetGridNull*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reverse'", NULL);
#endif
  {
   CCFiniteTimeAction* tolua_ret = (CCFiniteTimeAction*)  self->reverse();
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCFiniteTimeAction");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reverse'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: copyWithZone of class  VSetGridNull */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSetGridNull_copyWithZone00
static int tolua_MyGame_VSetGridNull_copyWithZone00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VSetGridNull",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCZone",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VSetGridNull* self = (VSetGridNull*)  tolua_tousertype(tolua_S,1,0);
  CCZone* pZone = ((CCZone*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'copyWithZone'", NULL);
#endif
  {
   CCObject* tolua_ret = (CCObject*)  self->copyWithZone(pZone);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCObject");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'copyWithZone'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: action of class  VSetGridNull */
#ifndef TOLUA_DISABLE_tolua_MyGame_VSetGridNull_action00
static int tolua_MyGame_VSetGridNull_action00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VSetGridNull",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VSetGridNull* tolua_ret = (VSetGridNull*)  VSetGridNull::action();
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"VSetGridNull");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'action'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  VNodeRunAction */
#ifndef TOLUA_DISABLE_tolua_MyGame_VNodeRunAction_new00
static int tolua_MyGame_VNodeRunAction_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VNodeRunAction",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VNodeRunAction* tolua_ret = (VNodeRunAction*)  Mtolua_new((VNodeRunAction)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"VNodeRunAction");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  VNodeRunAction */
#ifndef TOLUA_DISABLE_tolua_MyGame_VNodeRunAction_new00_local
static int tolua_MyGame_VNodeRunAction_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VNodeRunAction",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VNodeRunAction* tolua_ret = (VNodeRunAction*)  Mtolua_new((VNodeRunAction)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"VNodeRunAction");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  VNodeRunAction */
#ifndef TOLUA_DISABLE_tolua_MyGame_VNodeRunAction_delete00
static int tolua_MyGame_VNodeRunAction_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VNodeRunAction",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VNodeRunAction* self = (VNodeRunAction*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: startWithTarget of class  VNodeRunAction */
#ifndef TOLUA_DISABLE_tolua_MyGame_VNodeRunAction_startWithTarget00
static int tolua_MyGame_VNodeRunAction_startWithTarget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VNodeRunAction",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VNodeRunAction* self = (VNodeRunAction*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pTarget = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'startWithTarget'", NULL);
#endif
  {
   self->startWithTarget(pTarget);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'startWithTarget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reverse of class  VNodeRunAction */
#ifndef TOLUA_DISABLE_tolua_MyGame_VNodeRunAction_reverse00
static int tolua_MyGame_VNodeRunAction_reverse00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VNodeRunAction",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VNodeRunAction* self = (VNodeRunAction*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reverse'", NULL);
#endif
  {
   CCFiniteTimeAction* tolua_ret = (CCFiniteTimeAction*)  self->reverse();
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCFiniteTimeAction");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reverse'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: copyWithZone of class  VNodeRunAction */
#ifndef TOLUA_DISABLE_tolua_MyGame_VNodeRunAction_copyWithZone00
static int tolua_MyGame_VNodeRunAction_copyWithZone00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VNodeRunAction",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCZone",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VNodeRunAction* self = (VNodeRunAction*)  tolua_tousertype(tolua_S,1,0);
  CCZone* pZone = ((CCZone*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'copyWithZone'", NULL);
#endif
  {
   CCObject* tolua_ret = (CCObject*)  self->copyWithZone(pZone);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCObject");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'copyWithZone'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initWithNodeName of class  VNodeRunAction */
#ifndef TOLUA_DISABLE_tolua_MyGame_VNodeRunAction_initWithNodeName00
static int tolua_MyGame_VNodeRunAction_initWithNodeName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VNodeRunAction",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VNodeRunAction* self = (VNodeRunAction*)  tolua_tousertype(tolua_S,1,0);
  const char* nodeName = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* actName = ((const char*)  tolua_tostring(tolua_S,3,0));
  const char* ccatFile = ((const char*)  tolua_tostring(tolua_S,4,0));
  FindFromType findType = ((FindFromType) (int)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initWithNodeName'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->initWithNodeName(nodeName,actName,ccatFile,findType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initWithNodeName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: actionWithNodeName of class  VNodeRunAction */
#ifndef TOLUA_DISABLE_tolua_MyGame_VNodeRunAction_actionWithNodeName00
static int tolua_MyGame_VNodeRunAction_actionWithNodeName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VNodeRunAction",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* nodeName = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* actName = ((const char*)  tolua_tostring(tolua_S,3,0));
  const char* ccatFile = ((const char*)  tolua_tostring(tolua_S,4,0));
  FindFromType findType = ((FindFromType) (int)  tolua_tonumber(tolua_S,5,0));
  {
   VNodeRunAction* tolua_ret = (VNodeRunAction*)  VNodeRunAction::actionWithNodeName(nodeName,actName,ccatFile,findType);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"VNodeRunAction");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'actionWithNodeName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  VCC2DLoad */
#ifndef TOLUA_DISABLE_tolua_MyGame_VCC2DLoad_new00
static int tolua_MyGame_VCC2DLoad_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VCC2DLoad",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VCC2DLoad* tolua_ret = (VCC2DLoad*)  Mtolua_new((VCC2DLoad)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"VCC2DLoad");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  VCC2DLoad */
#ifndef TOLUA_DISABLE_tolua_MyGame_VCC2DLoad_new00_local
static int tolua_MyGame_VCC2DLoad_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VCC2DLoad",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   VCC2DLoad* tolua_ret = (VCC2DLoad*)  Mtolua_new((VCC2DLoad)());
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"VCC2DLoad");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  VCC2DLoad */
#ifndef TOLUA_DISABLE_tolua_MyGame_VCC2DLoad_delete00
static int tolua_MyGame_VCC2DLoad_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VCC2DLoad",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VCC2DLoad* self = (VCC2DLoad*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: startWithTarget of class  VCC2DLoad */
#ifndef TOLUA_DISABLE_tolua_MyGame_VCC2DLoad_startWithTarget00
static int tolua_MyGame_VCC2DLoad_startWithTarget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VCC2DLoad",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VCC2DLoad* self = (VCC2DLoad*)  tolua_tousertype(tolua_S,1,0);
  CCNode* pTarget = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'startWithTarget'", NULL);
#endif
  {
   self->startWithTarget(pTarget);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'startWithTarget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reverse of class  VCC2DLoad */
#ifndef TOLUA_DISABLE_tolua_MyGame_VCC2DLoad_reverse00
static int tolua_MyGame_VCC2DLoad_reverse00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VCC2DLoad",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VCC2DLoad* self = (VCC2DLoad*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reverse'", NULL);
#endif
  {
   CCFiniteTimeAction* tolua_ret = (CCFiniteTimeAction*)  self->reverse();
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCFiniteTimeAction");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reverse'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: copyWithZone of class  VCC2DLoad */
#ifndef TOLUA_DISABLE_tolua_MyGame_VCC2DLoad_copyWithZone00
static int tolua_MyGame_VCC2DLoad_copyWithZone00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VCC2DLoad",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCZone",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VCC2DLoad* self = (VCC2DLoad*)  tolua_tousertype(tolua_S,1,0);
  CCZone* pZone = ((CCZone*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'copyWithZone'", NULL);
#endif
  {
   CCObject* tolua_ret = (CCObject*)  self->copyWithZone(pZone);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCObject");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'copyWithZone'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initWithFile of class  VCC2DLoad */
#ifndef TOLUA_DISABLE_tolua_MyGame_VCC2DLoad_initWithFile00
static int tolua_MyGame_VCC2DLoad_initWithFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"VCC2DLoad",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  VCC2DLoad* self = (VCC2DLoad*)  tolua_tousertype(tolua_S,1,0);
  const char* cc2dFile = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* parentNodeName = ((const char*)  tolua_tostring(tolua_S,3,0));
  FindFromType findType = ((FindFromType) (int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initWithFile'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->initWithFile(cc2dFile,parentNodeName,findType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initWithFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: actionWithFile of class  VCC2DLoad */
#ifndef TOLUA_DISABLE_tolua_MyGame_VCC2DLoad_actionWithFile00
static int tolua_MyGame_VCC2DLoad_actionWithFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"VCC2DLoad",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* cc2dFile = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* parentNodeName = ((const char*)  tolua_tostring(tolua_S,3,0));
  FindFromType findType = ((FindFromType) (int)  tolua_tonumber(tolua_S,4,0));
  {
   VCC2DLoad* tolua_ret = (VCC2DLoad*)  VCC2DLoad::actionWithFile(cc2dFile,parentNodeName,findType);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"VCC2DLoad");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'actionWithFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_new00
static int tolua_MyGame_SpriteExt_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   SpriteExt* tolua_ret = (SpriteExt*)  Mtolua_new((SpriteExt)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"SpriteExt");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_new00_local
static int tolua_MyGame_SpriteExt_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   SpriteExt* tolua_ret = (SpriteExt*)  Mtolua_new((SpriteExt)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"SpriteExt");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_delete00
static int tolua_MyGame_SpriteExt_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  SpriteExt* self = (SpriteExt*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: spriteWithFile of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_spriteWithFile00
static int tolua_MyGame_SpriteExt_spriteWithFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* pszFileName = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   SpriteExt* tolua_ret = (SpriteExt*)  SpriteExt::spriteWithFile(pszFileName);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"SpriteExt");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'spriteWithFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: spriteWithFile of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_spriteWithFile01
static int tolua_MyGame_SpriteExt_spriteWithFile01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const CCRect",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const char* pszFileName = ((const char*)  tolua_tostring(tolua_S,2,0));
  const CCRect* rect = ((const CCRect*)  tolua_tousertype(tolua_S,3,0));
  {
   SpriteExt* tolua_ret = (SpriteExt*)  SpriteExt::spriteWithFile(pszFileName,*rect);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"SpriteExt");
  }
 }
 return 1;
tolua_lerror:
 return tolua_MyGame_SpriteExt_spriteWithFile00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFlag of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_getFlag00
static int tolua_MyGame_SpriteExt_getFlag00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const SpriteExt",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const SpriteExt* self = (const SpriteExt*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFlag'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getFlag();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFlag'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFlag of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_setFlag00
static int tolua_MyGame_SpriteExt_setFlag00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  SpriteExt* self = (SpriteExt*)  tolua_tousertype(tolua_S,1,0);
  const std::string strFlag = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFlag'", NULL);
#endif
  {
   self->setFlag(strFlag);
   tolua_pushcppstring(tolua_S,(const char*)strFlag);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFlag'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDispearAction of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_setDispearAction00
static int tolua_MyGame_SpriteExt_setDispearAction00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  SpriteExt* self = (SpriteExt*)  tolua_tousertype(tolua_S,1,0);
  const std::string dispearAction = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDispearAction'", NULL);
#endif
  {
   self->setDispearAction(dispearAction);
   tolua_pushcppstring(tolua_S,(const char*)dispearAction);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDispearAction'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setCcatFile of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_setCcatFile00
static int tolua_MyGame_SpriteExt_setCcatFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  SpriteExt* self = (SpriteExt*)  tolua_tousertype(tolua_S,1,0);
  const std::string ccatFile = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCcatFile'", NULL);
#endif
  {
   self->setCcatFile(ccatFile);
   tolua_pushcppstring(tolua_S,(const char*)ccatFile);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCcatFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: dispear of class  SpriteExt */
#ifndef TOLUA_DISABLE_tolua_MyGame_SpriteExt_dispear00
static int tolua_MyGame_SpriteExt_dispear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"SpriteExt",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  SpriteExt* self = (SpriteExt*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'dispear'", NULL);
#endif
  {
   self->dispear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'dispear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getChildByName of class  Misc */
#ifndef TOLUA_DISABLE_tolua_MyGame_Misc_getChildByName00
static int tolua_MyGame_Misc_getChildByName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Misc",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
  const char* nodeName = ((const char*)  tolua_tostring(tolua_S,3,0));
  {
   CCNode* tolua_ret = (CCNode*)  Misc::getChildByName(pNode,nodeName);
    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;
    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;
    tolua_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getChildByName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNodeName of class  Misc */
#ifndef TOLUA_DISABLE_tolua_MyGame_Misc_getNodeName00
static int tolua_MyGame_Misc_getNodeName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Misc",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
  {
   std::string tolua_ret = (std::string)  Misc::getNodeName(pNode);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getNodeName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNodeName of class  Misc */
#ifndef TOLUA_DISABLE_tolua_MyGame_Misc_setNodeName00
static int tolua_MyGame_Misc_setNodeName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Misc",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
  const char* name = ((const char*)  tolua_tostring(tolua_S,3,0));
  {
   Misc::setNodeName(pNode,name);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setNodeName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUserData of class  Misc */
#ifndef TOLUA_DISABLE_tolua_MyGame_Misc_getUserData00
static int tolua_MyGame_Misc_getUserData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Misc",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
  {
   void* tolua_ret = (void*)  Misc::getUserData(pNode);
   tolua_pushuserdata(tolua_S,(void*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUserData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: log of class  Misc */
#ifndef TOLUA_DISABLE_tolua_MyGame_Misc_log00
static int tolua_MyGame_Misc_log00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Misc",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* msg = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   Misc::log(msg);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'log'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fullPathFile of class  Misc */
#ifndef TOLUA_DISABLE_tolua_MyGame_Misc_fullPathFile00
static int tolua_MyGame_Misc_fullPathFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Misc",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* filename = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   std::string tolua_ret = (std::string)  Misc::fullPathFile(filename);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fullPathFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: collideNode of class  Misc */
#ifndef TOLUA_DISABLE_tolua_MyGame_Misc_collideNode00
static int tolua_MyGame_Misc_collideNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Misc",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"CCNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCNode* node1 = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
  CCNode* node2 = ((CCNode*)  tolua_tousertype(tolua_S,3,0));
  {
   bool tolua_ret = (bool)  Misc::collideNode(node1,node2);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'collideNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  UIWidget */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIWidget_new00
static int tolua_MyGame_UIWidget_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"UIWidget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   UIWidget* tolua_ret = (UIWidget*)  Mtolua_new((UIWidget)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"UIWidget");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  UIWidget */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIWidget_new00_local
static int tolua_MyGame_UIWidget_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"UIWidget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   UIWidget* tolua_ret = (UIWidget*)  Mtolua_new((UIWidget)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"UIWidget");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  UIWidget */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIWidget_delete00
static int tolua_MyGame_UIWidget_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"UIWidget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  UIWidget* self = (UIWidget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: init of class  UIWidget */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIWidget_init00
static int tolua_MyGame_UIWidget_init00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"UIWidget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  UIWidget* self = (UIWidget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'init'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->init();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'init'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: create of class  UIWidget */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIWidget_create00
static int tolua_MyGame_UIWidget_create00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"UIWidget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   UIWidget* tolua_ret = (UIWidget*)  UIWidget::create();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"UIWidget");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'create'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  UIButton */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIButton_new00
static int tolua_MyGame_UIButton_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"UIButton",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   UIButton* tolua_ret = (UIButton*)  Mtolua_new((UIButton)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"UIButton");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  UIButton */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIButton_new00_local
static int tolua_MyGame_UIButton_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"UIButton",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   UIButton* tolua_ret = (UIButton*)  Mtolua_new((UIButton)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"UIButton");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  UIButton */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIButton_delete00
static int tolua_MyGame_UIButton_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"UIButton",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  UIButton* self = (UIButton*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: create of class  UIButton */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIButton_create00
static int tolua_MyGame_UIButton_create00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"UIButton",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,1,&tolua_err) ||
     !tolua_isstring(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* normalFile = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* selectedFile = ((const char*)  tolua_tostring(tolua_S,3,NULL));
  const char* disabledFile = ((const char*)  tolua_tostring(tolua_S,4,NULL));
  {
   UIButton* tolua_ret = (UIButton*)  UIButton::create(normalFile,selectedFile,disabledFile);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"UIButton");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'create'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initWithNormalImage of class  UIButton */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIButton_initWithNormalImage00
static int tolua_MyGame_UIButton_initWithNormalImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"UIButton",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,1,&tolua_err) ||
     !tolua_isstring(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  UIButton* self = (UIButton*)  tolua_tousertype(tolua_S,1,0);
  const char* normalFile = ((const char*)  tolua_tostring(tolua_S,2,0));
  const char* selectedFile = ((const char*)  tolua_tostring(tolua_S,3,NULL));
  const char* disabledFile = ((const char*)  tolua_tostring(tolua_S,4,NULL));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initWithNormalImage'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->initWithNormalImage(normalFile,selectedFile,disabledFile);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initWithNormalImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: registerScriptActiveHandler of class  UIButton */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIButton_registerScriptActiveHandler00
static int tolua_MyGame_UIButton_registerScriptActiveHandler00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"UIButton",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isfunction(tolua_S,2,"int",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  UIButton* self = (UIButton*)  tolua_tousertype(tolua_S,1,0);
  int nHandler = (  tolua_ref_function(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'registerScriptActiveHandler'", NULL);
#endif
  {
   self->registerScriptActiveHandler(nHandler);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'registerScriptActiveHandler'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: unregisterScriptActiveHandler of class  UIButton */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIButton_unregisterScriptActiveHandler00
static int tolua_MyGame_UIButton_unregisterScriptActiveHandler00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"UIButton",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  UIButton* self = (UIButton*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unregisterScriptActiveHandler'", NULL);
#endif
  {
   self->unregisterScriptActiveHandler();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'unregisterScriptActiveHandler'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: activate of class  UIButton */
#ifndef TOLUA_DISABLE_tolua_MyGame_UIButton_activate00
static int tolua_MyGame_UIButton_activate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"UIButton",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  UIButton* self = (UIButton*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'activate'", NULL);
#endif
  {
   self->activate();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'activate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
TOLUA_API int tolua_MyGame_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,NULL,0);
 tolua_beginmodule(tolua_S,NULL);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DFileCache","CC2DFileCache","CCObject",tolua_collect_CC2DFileCache);
  #else
  tolua_cclass(tolua_S,"CC2DFileCache","CC2DFileCache","CCObject",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DFileCache");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DFileCache_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DFileCache_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DFileCache_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DFileCache_delete00);
   tolua_function(tolua_S,"sharedCC2DFileCache",tolua_MyGame_CC2DFileCache_sharedCC2DFileCache00);
   tolua_function(tolua_S,"addCC2DNode",tolua_MyGame_CC2DFileCache_addCC2DNode00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DNode","CC2DNode","CCObject",tolua_collect_CC2DNode);
  #else
  tolua_cclass(tolua_S,"CC2DNode","CC2DNode","CCObject",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DNode");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DNode_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DNode_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DNode_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DNode_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DNode_createCCNode00);
   tolua_function(tolua_S,"initProperties",tolua_MyGame_CC2DNode_initProperties00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DNode_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DSprite","CC2DSprite","CC2DNode",tolua_collect_CC2DSprite);
  #else
  tolua_cclass(tolua_S,"CC2DSprite","CC2DSprite","CC2DNode",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DSprite");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DSprite_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DSprite_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DSprite_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DSprite_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DSprite_createCCNode00);
   tolua_function(tolua_S,"initProperties",tolua_MyGame_CC2DSprite_initProperties00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DSprite_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DParticleSystem","CC2DParticleSystem","CC2DNode",tolua_collect_CC2DParticleSystem);
  #else
  tolua_cclass(tolua_S,"CC2DParticleSystem","CC2DParticleSystem","CC2DNode",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DParticleSystem");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DParticleSystem_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DParticleSystem_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DParticleSystem_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DParticleSystem_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DParticleSystem_createCCNode00);
   tolua_function(tolua_S,"initProperties",tolua_MyGame_CC2DParticleSystem_initProperties00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DParticleSystem_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DLayer","CC2DLayer","CC2DNode",tolua_collect_CC2DLayer);
  #else
  tolua_cclass(tolua_S,"CC2DLayer","CC2DLayer","CC2DNode",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DLayer");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DLayer_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DLayer_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DLayer_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DLayer_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DLayer_createCCNode00);
   tolua_function(tolua_S,"initProperties",tolua_MyGame_CC2DLayer_initProperties00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DLayer_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DProgressTimer","CC2DProgressTimer","CC2DNode",tolua_collect_CC2DProgressTimer);
  #else
  tolua_cclass(tolua_S,"CC2DProgressTimer","CC2DProgressTimer","CC2DNode",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DProgressTimer");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DProgressTimer_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DProgressTimer_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DProgressTimer_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DProgressTimer_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DProgressTimer_createCCNode00);
   tolua_function(tolua_S,"initProperties",tolua_MyGame_CC2DProgressTimer_initProperties00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DProgressTimer_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DParallaxNode","CC2DParallaxNode","CC2DNode",tolua_collect_CC2DParallaxNode);
  #else
  tolua_cclass(tolua_S,"CC2DParallaxNode","CC2DParallaxNode","CC2DNode",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DParallaxNode");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DParallaxNode_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DParallaxNode_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DParallaxNode_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DParallaxNode_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DParallaxNode_createCCNode00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DScene","CC2DScene","CC2DNode",tolua_collect_CC2DScene);
  #else
  tolua_cclass(tolua_S,"CC2DScene","CC2DScene","CC2DNode",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DScene");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DScene_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DScene_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DScene_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DScene_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DScene_createCCNode00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DMenu","CC2DMenu","CC2DNode",tolua_collect_CC2DMenu);
  #else
  tolua_cclass(tolua_S,"CC2DMenu","CC2DMenu","CC2DNode",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DMenu");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DMenu_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DMenu_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DMenu_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DMenu_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DMenu_createCCNode00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DMenuItemImage","CC2DMenuItemImage","CC2DNode",tolua_collect_CC2DMenuItemImage);
  #else
  tolua_cclass(tolua_S,"CC2DMenuItemImage","CC2DMenuItemImage","CC2DNode",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DMenuItemImage");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DMenuItemImage_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DMenuItemImage_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DMenuItemImage_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DMenuItemImage_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DMenuItemImage_createCCNode00);
   tolua_function(tolua_S,"initProperties",tolua_MyGame_CC2DMenuItemImage_initProperties00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DMenuItemImage_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DSpriteExt","CC2DSpriteExt","CC2DSprite",tolua_collect_CC2DSpriteExt);
  #else
  tolua_cclass(tolua_S,"CC2DSpriteExt","CC2DSpriteExt","CC2DSprite",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DSpriteExt");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DSpriteExt_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DSpriteExt_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DSpriteExt_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DSpriteExt_delete00);
   tolua_function(tolua_S,"createCCNode",tolua_MyGame_CC2DSpriteExt_createCCNode00);
   tolua_function(tolua_S,"initProperties",tolua_MyGame_CC2DSpriteExt_initProperties00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DSpriteExt_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DWorld","CC2DWorld","CCObject",tolua_collect_CC2DWorld);
  #else
  tolua_cclass(tolua_S,"CC2DWorld","CC2DWorld","CCObject",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DWorld");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DWorld_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DWorld_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DWorld_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DWorld_delete00);
   tolua_function(tolua_S,"createWorld",tolua_MyGame_CC2DWorld_createWorld00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DWorld_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DBody","CC2DBody","CCObject",tolua_collect_CC2DBody);
  #else
  tolua_cclass(tolua_S,"CC2DBody","CC2DBody","CCObject",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DBody");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DBody_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DBody_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DBody_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DBody_delete00);
   tolua_function(tolua_S,"createBody",tolua_MyGame_CC2DBody_createBody00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DBody_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DCircle","CC2DCircle","CC2DFixture",tolua_collect_CC2DCircle);
  #else
  tolua_cclass(tolua_S,"CC2DCircle","CC2DCircle","CC2DFixture",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DCircle");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DCircle_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DCircle_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DCircle_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DCircle_delete00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DCircle_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DRectangle","CC2DRectangle","CC2DFixture",tolua_collect_CC2DRectangle);
  #else
  tolua_cclass(tolua_S,"CC2DRectangle","CC2DRectangle","CC2DFixture",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DRectangle");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DRectangle_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DRectangle_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DRectangle_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DRectangle_delete00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DRectangle_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CC2DPolygon","CC2DPolygon","CC2DFixture",tolua_collect_CC2DPolygon);
  #else
  tolua_cclass(tolua_S,"CC2DPolygon","CC2DPolygon","CC2DFixture",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CC2DPolygon");
   tolua_function(tolua_S,"new",tolua_MyGame_CC2DPolygon_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CC2DPolygon_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CC2DPolygon_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CC2DPolygon_delete00);
   tolua_function(tolua_S,"load",tolua_MyGame_CC2DPolygon_load00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CCATFileCache","CCATFileCache","CCObject",tolua_collect_CCATFileCache);
  #else
  tolua_cclass(tolua_S,"CCATFileCache","CCATFileCache","CCObject",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CCATFileCache");
   tolua_function(tolua_S,"new",tolua_MyGame_CCATFileCache_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_CCATFileCache_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_CCATFileCache_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_CCATFileCache_delete00);
   tolua_function(tolua_S,"sharedCCATFileCache",tolua_MyGame_CCATFileCache_sharedCCATFileCache00);
   tolua_function(tolua_S,"findAction",tolua_MyGame_CCATFileCache_findAction00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"XmlParser","XmlParser","",tolua_collect_XmlParser);
  #else
  tolua_cclass(tolua_S,"XmlParser","XmlParser","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"XmlParser");
   tolua_function(tolua_S,"new",tolua_MyGame_XmlParser_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_XmlParser_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_XmlParser_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_XmlParser_delete00);
   tolua_function(tolua_S,"getBoolForKey",tolua_MyGame_XmlParser_getBoolForKey00);
   tolua_function(tolua_S,"getIntegerForKey",tolua_MyGame_XmlParser_getIntegerForKey00);
   tolua_function(tolua_S,"getIntArrayForKey",tolua_MyGame_XmlParser_getIntArrayForKey00);
   tolua_function(tolua_S,"getFloatArrayForKey",tolua_MyGame_XmlParser_getFloatArrayForKey00);
   tolua_function(tolua_S,"getFloatForKey",tolua_MyGame_XmlParser_getFloatForKey00);
   tolua_function(tolua_S,"getDoubleForKey",tolua_MyGame_XmlParser_getDoubleForKey00);
   tolua_function(tolua_S,"getRectForKey",tolua_MyGame_XmlParser_getRectForKey00);
   tolua_function(tolua_S,"getRectForKey",tolua_MyGame_XmlParser_getRectForKey01);
   tolua_function(tolua_S,"getPointForKey",tolua_MyGame_XmlParser_getPointForKey00);
   tolua_function(tolua_S,"getPointForKey",tolua_MyGame_XmlParser_getPointForKey01);
   tolua_function(tolua_S,"getSizeForKey",tolua_MyGame_XmlParser_getSizeForKey00);
   tolua_function(tolua_S,"getSizeForKey",tolua_MyGame_XmlParser_getSizeForKey01);
   tolua_function(tolua_S,"getStringForKey",tolua_MyGame_XmlParser_getStringForKey00);
   tolua_function(tolua_S,"gotoNextGroup",tolua_MyGame_XmlParser_gotoNextGroup00);
   tolua_function(tolua_S,"gotoChildGroup",tolua_MyGame_XmlParser_gotoChildGroup00);
   tolua_function(tolua_S,"curNodeName",tolua_MyGame_XmlParser_curNodeName00);
   tolua_function(tolua_S,"allPropertyNames",tolua_MyGame_XmlParser_allPropertyNames00);
   tolua_function(tolua_S,"setBoolForKey",tolua_MyGame_XmlParser_setBoolForKey00);
   tolua_function(tolua_S,"setIntegerForKey",tolua_MyGame_XmlParser_setIntegerForKey00);
   tolua_function(tolua_S,"setFloatForKey",tolua_MyGame_XmlParser_setFloatForKey00);
   tolua_function(tolua_S,"setDoubleForKey",tolua_MyGame_XmlParser_setDoubleForKey00);
   tolua_function(tolua_S,"setStringForKey",tolua_MyGame_XmlParser_setStringForKey00);
   tolua_function(tolua_S,"setAtrribute",tolua_MyGame_XmlParser_setAtrribute00);
   tolua_function(tolua_S,"getAttribute",tolua_MyGame_XmlParser_getAttribute00);
   tolua_function(tolua_S,"getIntegerForAttr",tolua_MyGame_XmlParser_getIntegerForAttr00);
   tolua_function(tolua_S,"getPointForAttr",tolua_MyGame_XmlParser_getPointForAttr00);
   tolua_function(tolua_S,"getPointForAttr",tolua_MyGame_XmlParser_getPointForAttr01);
   tolua_function(tolua_S,"getRectForAttr",tolua_MyGame_XmlParser_getRectForAttr00);
   tolua_function(tolua_S,"getRectForAttr",tolua_MyGame_XmlParser_getRectForAttr01);
   tolua_function(tolua_S,"getSizeForAttr",tolua_MyGame_XmlParser_getSizeForAttr00);
   tolua_function(tolua_S,"getSizeForAttr",tolua_MyGame_XmlParser_getSizeForAttr01);
   tolua_function(tolua_S,"getColorForAttr",tolua_MyGame_XmlParser_getColorForAttr00);
   tolua_function(tolua_S,"getColorForAttr",tolua_MyGame_XmlParser_getColorForAttr01);
   tolua_function(tolua_S,"getDoubleForAttr",tolua_MyGame_XmlParser_getDoubleForAttr00);
   tolua_function(tolua_S,"getFloatForAttr",tolua_MyGame_XmlParser_getFloatForAttr00);
   tolua_function(tolua_S,"beginGroup",tolua_MyGame_XmlParser_beginGroup00);
   tolua_function(tolua_S,"endGroup",tolua_MyGame_XmlParser_endGroup00);
   tolua_function(tolua_S,"initXMLFile",tolua_MyGame_XmlParser_initXMLFile00);
   tolua_function(tolua_S,"saveXMLFile",tolua_MyGame_XmlParser_saveXMLFile00);
   tolua_function(tolua_S,"reset",tolua_MyGame_XmlParser_reset00);
   tolua_function(tolua_S,"isXMLFileExist",tolua_MyGame_XmlParser_isXMLFileExist00);
   tolua_function(tolua_S,"getFileName",tolua_MyGame_XmlParser_getFileName00);
   tolua_function(tolua_S,"newGroup",tolua_MyGame_XmlParser_newGroup00);
   tolua_function(tolua_S,"createXMLFile",tolua_MyGame_XmlParser_createXMLFile00);
   tolua_function(tolua_S,"getXMLNodeForKey",tolua_MyGame_XmlParser_getXMLNodeForKey00);
   tolua_function(tolua_S,"getValueForKey",tolua_MyGame_XmlParser_getValueForKey00);
   tolua_function(tolua_S,"setValueForKey",tolua_MyGame_XmlParser_setValueForKey00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"VSoundPlay","VSoundPlay","CCActionInstant",tolua_collect_VSoundPlay);
  #else
  tolua_cclass(tolua_S,"VSoundPlay","VSoundPlay","CCActionInstant",NULL);
  #endif
  tolua_beginmodule(tolua_S,"VSoundPlay");
   tolua_function(tolua_S,"new",tolua_MyGame_VSoundPlay_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_VSoundPlay_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_VSoundPlay_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_VSoundPlay_delete00);
   tolua_function(tolua_S,"initWithFile",tolua_MyGame_VSoundPlay_initWithFile00);
   tolua_function(tolua_S,"startWithTarget",tolua_MyGame_VSoundPlay_startWithTarget00);
   tolua_function(tolua_S,"reverse",tolua_MyGame_VSoundPlay_reverse00);
   tolua_function(tolua_S,"copyWithZone",tolua_MyGame_VSoundPlay_copyWithZone00);
   tolua_function(tolua_S,"action",tolua_MyGame_VSoundPlay_action00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"VDeleteNode","VDeleteNode","CCActionInstant",tolua_collect_VDeleteNode);
  #else
  tolua_cclass(tolua_S,"VDeleteNode","VDeleteNode","CCActionInstant",NULL);
  #endif
  tolua_beginmodule(tolua_S,"VDeleteNode");
   tolua_function(tolua_S,"new",tolua_MyGame_VDeleteNode_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_VDeleteNode_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_VDeleteNode_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_VDeleteNode_delete00);
   tolua_function(tolua_S,"startWithTarget",tolua_MyGame_VDeleteNode_startWithTarget00);
   tolua_function(tolua_S,"reverse",tolua_MyGame_VDeleteNode_reverse00);
   tolua_function(tolua_S,"copyWithZone",tolua_MyGame_VDeleteNode_copyWithZone00);
   tolua_function(tolua_S,"action",tolua_MyGame_VDeleteNode_action00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"VSetGridNull","VSetGridNull","CCActionInstant",tolua_collect_VSetGridNull);
  #else
  tolua_cclass(tolua_S,"VSetGridNull","VSetGridNull","CCActionInstant",NULL);
  #endif
  tolua_beginmodule(tolua_S,"VSetGridNull");
   tolua_function(tolua_S,"new",tolua_MyGame_VSetGridNull_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_VSetGridNull_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_VSetGridNull_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_VSetGridNull_delete00);
   tolua_function(tolua_S,"startWithTarget",tolua_MyGame_VSetGridNull_startWithTarget00);
   tolua_function(tolua_S,"reverse",tolua_MyGame_VSetGridNull_reverse00);
   tolua_function(tolua_S,"copyWithZone",tolua_MyGame_VSetGridNull_copyWithZone00);
   tolua_function(tolua_S,"action",tolua_MyGame_VSetGridNull_action00);
  tolua_endmodule(tolua_S);
  tolua_constant(tolua_S,"FindFrom_Sefl",FindFrom_Sefl);
  tolua_constant(tolua_S,"FindFrom_Parent",FindFrom_Parent);
  tolua_constant(tolua_S,"FindFrom_Global",FindFrom_Global);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"VNodeRunAction","VNodeRunAction","CCActionInstant",tolua_collect_VNodeRunAction);
  #else
  tolua_cclass(tolua_S,"VNodeRunAction","VNodeRunAction","CCActionInstant",NULL);
  #endif
  tolua_beginmodule(tolua_S,"VNodeRunAction");
   tolua_function(tolua_S,"new",tolua_MyGame_VNodeRunAction_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_VNodeRunAction_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_VNodeRunAction_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_VNodeRunAction_delete00);
   tolua_function(tolua_S,"startWithTarget",tolua_MyGame_VNodeRunAction_startWithTarget00);
   tolua_function(tolua_S,"reverse",tolua_MyGame_VNodeRunAction_reverse00);
   tolua_function(tolua_S,"copyWithZone",tolua_MyGame_VNodeRunAction_copyWithZone00);
   tolua_function(tolua_S,"initWithNodeName",tolua_MyGame_VNodeRunAction_initWithNodeName00);
   tolua_function(tolua_S,"actionWithNodeName",tolua_MyGame_VNodeRunAction_actionWithNodeName00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"VCC2DLoad","VCC2DLoad","CCActionInstant",tolua_collect_VCC2DLoad);
  #else
  tolua_cclass(tolua_S,"VCC2DLoad","VCC2DLoad","CCActionInstant",NULL);
  #endif
  tolua_beginmodule(tolua_S,"VCC2DLoad");
   tolua_function(tolua_S,"new",tolua_MyGame_VCC2DLoad_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_VCC2DLoad_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_VCC2DLoad_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_VCC2DLoad_delete00);
   tolua_function(tolua_S,"startWithTarget",tolua_MyGame_VCC2DLoad_startWithTarget00);
   tolua_function(tolua_S,"reverse",tolua_MyGame_VCC2DLoad_reverse00);
   tolua_function(tolua_S,"copyWithZone",tolua_MyGame_VCC2DLoad_copyWithZone00);
   tolua_function(tolua_S,"initWithFile",tolua_MyGame_VCC2DLoad_initWithFile00);
   tolua_function(tolua_S,"actionWithFile",tolua_MyGame_VCC2DLoad_actionWithFile00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"SpriteExt","SpriteExt","CCSprite",tolua_collect_SpriteExt);
  #else
  tolua_cclass(tolua_S,"SpriteExt","SpriteExt","CCSprite",NULL);
  #endif
  tolua_beginmodule(tolua_S,"SpriteExt");
   tolua_function(tolua_S,"new",tolua_MyGame_SpriteExt_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_SpriteExt_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_SpriteExt_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_SpriteExt_delete00);
   tolua_function(tolua_S,"spriteWithFile",tolua_MyGame_SpriteExt_spriteWithFile00);
   tolua_function(tolua_S,"spriteWithFile",tolua_MyGame_SpriteExt_spriteWithFile01);
   tolua_function(tolua_S,"getFlag",tolua_MyGame_SpriteExt_getFlag00);
   tolua_function(tolua_S,"setFlag",tolua_MyGame_SpriteExt_setFlag00);
   tolua_function(tolua_S,"setDispearAction",tolua_MyGame_SpriteExt_setDispearAction00);
   tolua_function(tolua_S,"setCcatFile",tolua_MyGame_SpriteExt_setCcatFile00);
   tolua_function(tolua_S,"dispear",tolua_MyGame_SpriteExt_dispear00);
  tolua_endmodule(tolua_S);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static const unsigned char B[] = {
    10,102,117,110, 99,116,105,111,110, 32, 67, 67, 95, 68, 69,
     71, 82, 69, 69, 83, 95, 84, 79, 95, 82, 65, 68, 73, 65, 78,
     83, 40, 95, 95, 65, 78, 71, 76, 69, 95, 95, 41, 10,114,101,
    116,117,114,110, 32, 40, 40, 95, 95, 65, 78, 71, 76, 69, 95,
     95, 41, 32, 42, 32, 48, 46, 48, 49, 55, 52, 53, 51, 50, 57,
     50, 53, 50, 41, 10,101,110,100, 10,102,117,110, 99,116,105,
    111,110, 32, 67, 67, 95, 82, 65, 68, 73, 65, 78, 83, 95, 84,
     79, 95, 68, 69, 71, 82, 69, 69, 83, 40, 95, 95, 65, 78, 71,
     76, 69, 95, 95, 41, 10,114,101,116,117,114,110, 32, 40, 40,
     95, 95, 65, 78, 71, 76, 69, 95, 95, 41, 32, 42, 32, 53, 55,
     46, 50, 57, 53, 55, 55, 57, 53, 49, 41, 10,101,110,100, 10,
     80, 84, 77, 95, 82, 65, 84, 73, 79, 32, 61, 32, 51, 48, 46,
     48, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 1");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

  tolua_cclass(tolua_S,"Misc","Misc","",NULL);
  tolua_beginmodule(tolua_S,"Misc");
   tolua_function(tolua_S,"getChildByName",tolua_MyGame_Misc_getChildByName00);
   tolua_function(tolua_S,"getNodeName",tolua_MyGame_Misc_getNodeName00);
   tolua_function(tolua_S,"setNodeName",tolua_MyGame_Misc_setNodeName00);
   tolua_function(tolua_S,"getUserData",tolua_MyGame_Misc_getUserData00);
   tolua_function(tolua_S,"log",tolua_MyGame_Misc_log00);
   tolua_function(tolua_S,"fullPathFile",tolua_MyGame_Misc_fullPathFile00);
   tolua_function(tolua_S,"collideNode",tolua_MyGame_Misc_collideNode00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"UIWidget","UIWidget","CCLayer",tolua_collect_UIWidget);
  #else
  tolua_cclass(tolua_S,"UIWidget","UIWidget","CCLayer",NULL);
  #endif
  tolua_beginmodule(tolua_S,"UIWidget");
   tolua_function(tolua_S,"new",tolua_MyGame_UIWidget_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_UIWidget_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_UIWidget_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_UIWidget_delete00);
   tolua_function(tolua_S,"init",tolua_MyGame_UIWidget_init00);
   tolua_function(tolua_S,"create",tolua_MyGame_UIWidget_create00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"UIButton","UIButton","UIWidget",tolua_collect_UIButton);
  #else
  tolua_cclass(tolua_S,"UIButton","UIButton","UIWidget",NULL);
  #endif
  tolua_beginmodule(tolua_S,"UIButton");
   tolua_function(tolua_S,"new",tolua_MyGame_UIButton_new00);
   tolua_function(tolua_S,"new_local",tolua_MyGame_UIButton_new00_local);
   tolua_function(tolua_S,".call",tolua_MyGame_UIButton_new00_local);
   tolua_function(tolua_S,"delete",tolua_MyGame_UIButton_delete00);
   tolua_function(tolua_S,"create",tolua_MyGame_UIButton_create00);
   tolua_function(tolua_S,"initWithNormalImage",tolua_MyGame_UIButton_initWithNormalImage00);
   tolua_function(tolua_S,"registerScriptActiveHandler",tolua_MyGame_UIButton_registerScriptActiveHandler00);
   tolua_function(tolua_S,"unregisterScriptActiveHandler",tolua_MyGame_UIButton_unregisterScriptActiveHandler00);
   tolua_function(tolua_S,"activate",tolua_MyGame_UIButton_activate00);
  tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 TOLUA_API int luaopen_MyGame (lua_State* tolua_S) {
 return tolua_MyGame_open(tolua_S);
};
#endif

